package com.hhz.stream.part1;

import com.hhz.lambda.part1.Employee;
import org.junit.Test;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

/**
 * Stream 的中间操作====筛选与切片
 * <p>
 * 多个中间操作可以链接起来形成一个流水线，除非流上发生终止操作，否则中间操作不会执行任何的处理！
 * 而在终止操作时一次性全部处理，称为“惰性求值”
 *
 * @Author Rem
 * @Date 2020-02-12
 */

public class TestStream2 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三", 16, 3468.12),
            new Employee("李四", 42, 9485.32),
            new Employee("王五", 24, 8482.99),
            new Employee("赵六", 33, 6381.82),
            new Employee("田七", 36, 4448.45),
            new Employee("田七", 36, 4448.45),
            new Employee("田七", 36, 4448.45),
            new Employee("方八", 36, 7485.42)
    );


    //中间操作

    /**
     * 筛选与切片
     * filter======接收Lambda,从流中排除某些元素
     * limit(n)====截断流。使元素不超过给定数量
     * skip(n)=====跳过元素，返回一个扔掉前n个元素的流。若流元素不足n个，则返回一个空流，与limit(n)互补
     * distinct====筛选，通过流所生成元素的hashCode()和equals()去除重复元素
     */


    //filter
    //内部迭代：迭代操作由Stream API 操作
    @Test
    public void test() {
        //中间操作:不会执行任何操作
        Stream<Employee> stream = employees.stream()
                .filter(e -> {
                    System.out.println("strem流的中间操作");
                    return e.getAge() > 35;
                });

        //终止操作：一次性执行全部内容，即“惰性求值”
        stream.forEach(System.out::println);
    }

    //外部迭代
    @Test
    public void test2() {
        Iterator<Employee> iterator = employees.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    //limit
    @Test
    public void test3() {
        employees.stream()
                .filter(e -> e.getSalary() > 5000)
                //取过滤后的前两个的流数据
                .limit(2)
                //终止操作
                .forEach(System.out::println);
    }

    //skip
    @Test
    public void test4() {
        employees.stream()
                .filter(e -> e.getSalary() > 5000)
                //取过滤后跳过前1个的流数据
                .skip(1)
                //终止操作
                .forEach(System.out::println);
    }

    //distinct
    @Test
    public void test5() {
        employees.stream()
                //去重操作（需要配合元素重写hash和eqals）
                .distinct()
                //终止操作
                .forEach(System.out::println);
    }


}
